local extension = Package("lzsj2")
extension.extensionName = "lzsj"

local U = require "packages/utility/utility"
local DIY = require "packages/diy_utility/diy_utility"
local ls = require 'packages/lvshisha/utility/lvshi_util'
local TT = require "packages/tuntian_studio/utility"

Fk:loadTranslationTable{
  ["lzsj2"] = "雷组-东北",
}


local gaogang = General(extension, "lzsj__gaogang", "gong", 4)
gaogang.strategy = "scheme"

local lzsj__zhangguoji = fk.CreateTriggerSkill{
  name = "lzsj__zhangguoji",
  events = {fk.EventPhaseStart},
  can_trigger = function(self, event, target, player, data)
    if target == player and player:hasSkill(self) then
      if player.phase == Player.Play then
        return not player:isKongcheng()
      elseif player.phase == Player.Discard then
        return player:getMark("@zhangguoji-turn") ~= 0 and player:getHandcardNum() > player:getMaxCards()
      end
    end
  end,
  on_cost = function(self, event, target, player, data)
    if player.phase == Player.Play then
      return player.room:askForSkillInvoke(player, self.name)
    else
      return true
    end
  end,
  on_use = function(self, event, target, player, data)
    local room = player.room
    if player.phase == Player.Play then
      local choices = {}
      for _, id in ipairs(player:getCardIds("h")) do
        table.insertIfNeed(choices, Fk:getCardById(id):getSuitString())
      end
      local choice = room:askForChoice(player, choices, self.name)
      room:setPlayerMark(player, "@zhangguoji-turn", {"log_"..choice})
      local n = #table.filter(player:getCardIds("h"), function (id) return Fk:getCardById(id):getSuitString() == choice end)
      player:drawCards(n, self.name)
    else
      local suit = player:getTableMark("@zhangguoji-turn")[1]
      local n = #table.filter(player:getCardIds("h"), function (id)
        return Fk:getCardById(id):getSuitString() == U.ConvertSuit(suit, "sym", "str") end)
      n = math.min(n, player:getHandcardNum() - player:getMaxCards())
      if n > 0 then
        room:askForDiscard(player, n, n, false, self.name, false, ".|.|"..U.ConvertSuit(suit, "sym", "str"), "#lzsj__zhangguoji")
      end
    end
  end,
}

gaogang:addSkill(lzsj__zhangguoji)

local lzsj__sangliaoxin = fk.CreateTriggerSkill{
  name = "lzsj__sangliaoxin",
  events = {fk.EventPhaseEnd, fk.Death},
  can_trigger = function(self, event, target, player, data)
    if event == fk.EventPhaseEnd then
      return target == player and player:hasSkill(self) and player.phase == Player.Play and player.room:getLord()
    else
      return player:hasSkill(self, true, true) and target == player and player:getMark("@@sangliaoxin") > 0
    end
  end,
  on_cost = function(self, event, target, player, data)
    if event == fk.EventPhaseEnd then
      return player.room:askForSkillInvoke(player, self.name)
    else
      return true
    end
  end,
  on_use = function(self, event, target, player, data)
    local room = player.room
    if event == fk.EventPhaseEnd then
      local lord = table.find(room.alive_players, function(p) return p.role == "lord" end)
      if table.every(room:getOtherPlayers(lord), function(p) return p:getHandcardNum() < lord:getHandcardNum() end)
      or table.every(room:getOtherPlayers(lord), function(p) return p.hp < lord.hp end) then
        local pattern = "sincere_treat"
        local names = U.getAllCardNames("t")
        if table.contains(names, "lvshi__secret_advance") then pattern = "lvshi__secret_advance" end
        room:useVirtualCard(pattern, nil, player, lord, self.name, true)
      else
        local targets = table.filter(room.alive_players, function (p) return lord.hp == p.hp end)
        local to = room:askForChoosePlayers(player, table.map(targets, Util.IdMapper), 1, 1, "#sangliaoxin-choose", self.name, false)
        if #to > 0 then
          room:addPlayerMark(player, "@@sangliaoxin")
          room:damage({
            from = player,
            to = room:getPlayerById(to[1]),
            damage = 1,
            damageType = fk.NormalDamage,
            skillName = self.name,
          })
        end
      end
    else
      room:setPlayerProperty(player, "role_shown", true)
      room:setPlayerProperty(player, "role", "renegade")
    end
  end,
  refresh_events = {fk.TurnStart},
  can_refresh = function(self, event, target, player, data)
    return player:hasSkill(self) and target == player and player:getMark("@@sangliaoxin") > 0
  end,
  on_refresh = function(self, event, target, player, data)
    player.room:setPlayerMark(player, "@@sangliaoxin", 0)
  end,
}

gaogang:addSkill(lzsj__sangliaoxin)

Fk:loadTranslationTable{
  ["lzsj__gaogang"] = "崇德",
  ["designer:lzsj__gaogang"] = "浩潇-淼龙",
  ["cv:lzsj__gaogang"] = "浩潇-淼龙",
  ["illustrator:lzsj__gaogang"] = "DALL·E3 ",
  ["lzsj__zhangguoji"] = "掌国计",
  ["@zhangguoji-turn"] = "掌国计",
  ["#lzsj__zhangguoji"] = "掌国计：请选择弃置的牌",
  [":lzsj__zhangguoji"] = "出牌阶段开始时，你可展示手牌中一种花色的所有牌并摸等量牌，若如此做，弃牌阶段开始时，你须弃置X张此花色的手牌（X为你超出手牌上限的手牌数，不足则全弃）",
  ["lzsj__sangliaoxin"] = "丧僚心",
  [":lzsj__sangliaoxin"] = "出牌阶段结束时，若主公的手牌数或体力值唯一最多，你可视为对其使用【暗度陈仓】，否则：你可对一名体力值与主公相同的角色造成1点伤害，然后直到你下回合开始，你死亡时身份改为内奸。",
  ["#sangliaoxin-choose"] = "你可选择一名体力值与主公相同的角色，对其造成1点伤害",
  ["@@sangliaoxin"] = "<font color=\"#45D7DF\">内奸！</font>",

  ["$lzsj__zhangguoji1"] = "鞍钢高炉昼夜转，铸的就是新国梁！",
  ["$lzsj__zhangguoji2"] = "五年计划草案？得先浇透我这杯高粱酒！",
  ["$lzsj__sangliaoxin1"] = "敌特名单上画个圈，明天台上少把椅子！",
  ["$lzsj__sangliaoxin2"] = "举报信摞成台阶，正好送老战友上路！",
  ["~lzsj__gaogang"] = "鞍钢铁水能铸国，怎就铸不牢这把交椅？",
}

local yangjingyu = General(extension, "lzsj__yangjingyu", "gong", 4)
yangjingyu.strategy = "courage"
local lzsj__yuehuangshi = fk.CreateTriggerSkill{
  name = "lzsj__yuehuangshi",
  events = {fk.CardUsing},
  can_trigger = function(self, event, target, player, data)
    return target ~= player and player:hasSkill(self) and player:usedSkillTimes(self.name, Player.HistoryRound) == 0
    and data.card.type == Card.TypeBasic and data.card.color == Card.Black
  end,
  on_use = function(self, event, target, player, data)
    local room = player.room
    data.nullifiedTargets = table.map(room.alive_players, Util.IdMapper)
    if not table.find(player:getCardIds("j"), function (id) return Fk:getCardById(id).trueName == "supply_shortage" end)
    and not data.card:isVirtual() then
      --ls.MoveAsDelayedTrick(data.card.id, player, "supply_shortage", self.name)
      local card = Fk:cloneCard("supply_shortage")
      card:addSubcard(data.card.id)
      player:addVirtualEquip(card)
      room:moveCardTo(card, Player.Judge, player, fk.ReasonJustMove, self.name)
    end
  end,
}

local lzsj__duandizi = fk.CreateActiveSkill{
  name = "lzsj__duandizi",
  anim_type = "control",
  card_num = 0,
  target_num = 0,
  prompt = "#lzsj__duandizi",
  interaction = function (self)
    local room = Fk:currentRoom()
    local choices = {}
    for _, p in ipairs(room.players) do
      if Self ~= p then
        local cards = table.filter(p:getCardIds("e"), function (id) return Fk:getCardById(id).color == Card.Black end)
        table.insertTableIfNeed(choices, cards)
      end
    end
    local all_choices = table.map(choices, function (id) return TT.getCardData(id, Fk:currentRoom()) end)
    return TT.CardNameBox { choices = choices, all_choices = all_choices, }
  end,
  can_use = function(self, player)
    return player:usedSkillTimes(self.name, Player.HistoryPhase) == 0
  end,
  card_filter = Util.FalseFunc,
  on_use = function(self, room, effect)
    local player = room:getPlayerById(effect.from)
    local target = room:getCardOwner(self.interaction.data)
    local cardResponded = room:askForResponse(target, 'jink', nil, nil, true, nil, effect)
    if cardResponded then
      room:responseCard({
        from = target.id,
        card = cardResponded,
        responseToEvent = effect,
      })
    else
      U.moveCardIntoEquip(room, player, self.interaction.data, self.name, true, player)
    end
  end,
}

local lzsj__juesizhi = fk.CreateViewAsSkill{
  name = "lzsj__juesizhi",
  pattern = "jink,nullification,unexpectation",
  prompt = "#lzsj__juesizhi",
  expand_pile = function (self, player)
    return player:getTableMark("lzsj__juesizhi")
  end,
  card_filter = function (self, to_select, selected)
    if #selected > 0 then return false end
    local mark = Self:getTableMark("lzsj__juesizhi")
    local names = {}
    for _, p in ipairs(Fk:currentRoom().players) do
      if p:getHandcardNum() == 1 then
        table.insertIfNeed(names, "unexpectation")
        if #p:getCardIds("ej") == 1 then
          table.insertIfNeed(names, "nullification")
        end
      end
      if #p:getCardIds("ej") == 1 then
        table.insertIfNeed(names, "jink")
      end
    end
    if #names == 0 then return end
    local juesizhi_cards = table.filter(U.getAllCardNames("bt"), function (name)
      return table.contains(names, Fk:cloneCard(name).trueName)
    end)
    local enable_cards = U.getViewAsCardNames(Self, self.name, juesizhi_cards)
    local name = Fk:getCardById(to_select).name
    return table.contains(mark, to_select) and table.contains(enable_cards, name)
  end,
  view_as = function(self, cards)
    if #cards ~= 1 then return end
    local card = Fk:cloneCard(Fk:getCardById(cards[1]).name)
    card.skillName = self.name
    return card
  end,
  before_use = function (self, player, use)
    local room = player.room
    local targets = {}
    if use.card.trueName == "unexpectation" then
      targets = table.filter(room.alive_players, function (p) return p:getHandcardNum() == 1 end)
    elseif use.card.trueName == "jink" then
      targets = table.filter(room.alive_players, function (p) return #p:getCardIds("ej") == 1 end)
    elseif use.card.trueName == "nullification" then
      targets = table.filter(room.alive_players, function (p) return p:getHandcardNum() == 1 and #p:getCardIds("ej") == 1 end)
    end
    if #targets == 0 then return "" end
    local tos = room:askForChoosePlayers(player, table.map(targets, Util.IdMapper), 1, 1, "#lzsj__juesizhi-choose", self.name, false)
    if #tos > 0 then
      local to = room:getPlayerById(tos[1])
      local cards
      if use.card.trueName == "unexpectation" then
        cards = to:getCardIds("h")
      elseif use.card.trueName == "jink" then
        cards = to:getCardIds("ej")
      elseif use.card.trueName == "nullification" then
        cards = to:getCardIds("hej")
      end
      use.card:addSubcards(cards)
      if player ~= to then
        if player:getMark("@@juesizhi-round") == 0 then
          room:addPlayerMark(player, "@@juesizhi-round")
        else
          local skills = {}
          for _, skill in ipairs(player.player_skills) do
            if skill:isPlayerSkill(player) and skill.visible then
              table.insert(skills, skill.name)
            end
          end
          local choice = room:askForChoice(player, skills, self.name, "#juesizhi-choice", true)
          room:handleAddLoseSkills(player, "-"..choice, nil, true, false)
        end
      end
    end
  end,
  enabled_at_play = Util.TrueFunc,
  enabled_at_response = function(self, player, response)
    return not response
  end,
  on_acquire = function(self, player)
    local cards = table.filter(U.getAllCardNames("bt"), function (name)
      return string.find(name, "jink") or string.find(name, "nullification") or string.find(name, "unexpectation")
    end)
    local mark = {player.room:printCard(cards[1]).id, player.room:printCard(cards[2]).id, player.room:printCard(cards[3]).id}
    player.room:setPlayerMark(player, "lzsj__juesizhi", mark)
  end,
}

yangjingyu:addSkill(lzsj__yuehuangshi)
yangjingyu:addSkill(lzsj__duandizi)
yangjingyu:addSkill(lzsj__juesizhi)

Fk:loadTranslationTable{
  ["lzsj__yangjingyu"] = "杨靖宇",
  ["designer:lzsj__yangjingyu"] = "浩潇-淼龙",
  ["cv:lzsj__yangjingyu"] = "浩潇-淼龙",
  ["lzsj__yuehuangshi"] = "越荒时",
  [":lzsj__yuehuangshi"] = "轮次技，其他角色使用黑色基本牌时，你可令之无效并将之置入你判定区。",
  ["lzsj__duandizi"] = "断敌辎",
  ["#lzsj__duandizi"] = "你可移动其他角色场上一张黑色装备牌至你",
  [":lzsj__duandizi"] = "阶段技，你可移动其他角色场上一张黑色装备牌至你（可替换原装备），其可打出一张【闪】取消之。",
  ["lzsj__juesizhi"] = "决死志",
  ["@@juesizhi-round"] = "<font color=\"#E8251E\"><b>决死志</b></font>",
  ["#lzsj__juesizhi"] = "请先选择使用牌的目标角色，使用时再选择失去牌的角色",
  ["#lzsj__juesizhi-choose"] = "请选择一名符合条件的角色",
  ["#juesizhi-choice"] = "请选择失去的技能",
  [":lzsj__juesizhi"] = "你可将一名角色的最后一张手牌/场上唯一的牌/两者同时当一张【出其不意】/【闪】/【无懈可击】使用。若你以此法选择其他角色的牌且不为此轮首次，你失去一个技能。",

  ["$lzsj__yuehuangshi1"] = "树皮嚼碎了咽下去，子弹嚼碎了吐出来！",
  ["$lzsj__yuehuangshi2"] = "雪地埋火种，寒夜藏刀锋！",
  ["$lzsj__duandizi1"] = "炸铁路！烧粮仓！",
  ["$lzsj__duandizi2"] = "一包炸药，换三车军粮！",
  ["$lzsj__juesizhi1"] = "最后一颗子弹留给我？不，留给关东军司令的脑袋！",
  ["$lzsj__juesizhi2"] = "要我投降？中国人都投降了还有中国吗？",
  ["~lzsj__yangjingyu"] = "胃里是棉絮草根，心里是山河故人。",
}

local zhangzuolin = General(extension, "lzsj__zhangzuolin", "fengtian", 4, 6)
zhangzuolin.strategy = "courage"
local lzsj__xuanzhushi = fk.CreateActiveSkill{
  name = "lzsj__xuanzhushi",
  anim_type = "support",
  card_num = 0,
  target_num = 1,
  prompt = "#lzsj__xuanzhushi",
  can_use = function(self, player)
    return player:usedSkillTimes(self.name, Player.HistoryPhase) == 0
  end,
  card_filter = Util.FalseFunc,
  target_filter = function (self, to_select, selected)
    return #selected == 0 and to_select ~= Self.id
  end,
  on_use = function(self, room, effect)
    local player = room:getPlayerById(effect.from)
    local to = room:getPlayerById(effect.tos[1])
    local cards = U.askforCardsChosenFromAreas(to, to, "hej", self.name, "#lzsj__xuanzhushi-choose", {}, false)
    local all_names = table.filter(U.getAllCardNames("b"), function (name) return not string.find(name, "poison") end)
    local names = table.filter(all_names, function (name) return player:canUseTo(Fk:cloneCard(name), to, {bypass_distances = true}) end)
    local choice = room:askForChoice(to, names, self.name, nil, false, all_names)
    room:useVirtualCard(choice, cards, to, player, self.name, true)
  end,
}

local xuanzhushi_trigger = fk.CreateTriggerSkill{
  name = "#lzsj__xuanzhushi_trigger",
  mute = true,
  events = {fk.CardUsing},
  can_trigger = function(self, event, target, player, data)
    return player:hasSkill(self) and data.card.skillName == "lzsj__xuanzhushi"
    and not player.room:getPlayerById(data.from):isKongcheng()
  end,
  on_cost = function(self, event, target, player, data)
    return player.room:askForSkillInvoke(player, self.name, nil, "#lzsj__xuanzhushi-show:"..data.from)
  end,
  on_use = function(self, event, target, player, data)
    local room = player.room
    local to = room:getPlayerById(data.from)
    local ids = table.random(to:getCardIds("h"), 1)
    to:showCards(ids)
    if not table.find(data.card.subcards, function (id) return Fk:getCardById(id).suit == Fk:getCardById(ids[1]).suit end) then
      data.nullifiedTargets = table.map(room.alive_players, Util.IdMapper)
    end
  end,
}


local lzsj__yunfenglei = fk.CreateTriggerSkill{
  name = "lzsj__yunfenglei",
  --anim_type = "control",
  mute = true,
  events = {fk.AfterCardsMove},
  can_trigger = function(self, event, target, player, data)
    if player:usedSkillTimes(self.name) == 0 and player:hasSkill(self) and player.room.current and player.room.current == player then
      for _, move in ipairs(data) do
        if move.from and player.room:getPlayerById(move.from):isAlive() and player.room:getPlayerById(move.from):isKongcheng() then
          for _, info in ipairs(move.moveInfo) do
            if info.fromArea == Card.PlayerHand then
              return true
            end
          end
        end
      end
    end
  end,
  on_cost = function(self, event, target, player, data)
    local room = player.room
    local to
    for _, move in ipairs(data) do
      to = room:getPlayerById(move.from)
    end
    local names = table.filter(U.getAllCardNames('t'), function (len)
      return string.find(len, "snatch")
    end)
    local cards = U.prepareDeriveCards(room, table.map(names, function (name)
      return {name, Card.NoSuit, 0} end), self.name)
    local use = U.askForUseRealCard(room, to, cards, nil, self.name, "#lzsj__yunfenglei-use",
      {expand_pile = cards, bypass_times = true}, true, true)
    if use then
      self.cost_data = use
      return true
    end
  end,
  on_use = function(self, event, target, player, data)
    player.room:notifySkillInvoked(player, self.name, "control")
    if ls.isFriend(player, player.room:getPlayerById(self.cost_data.from)) then
      player:broadcastSkillInvoke(self.name, 1)
    else
      player:broadcastSkillInvoke(self.name, 2)
    end
    local use = {
      card = Fk:cloneCard(self.cost_data.card.name),
      from = self.cost_data.from,
      tos = self.cost_data.tos,
      extraUse = true,
    }
    use.card.skillName = self.name
    player.room:useCard(use)
  end,
}

local lzsj__weijidao = fk.CreateTriggerSkill{
  name = "lzsj__weijidao",
  events = {fk.CardUseFinished},
  anim_type = "drawCards",
  can_trigger = function(self, event, target, player, data)
    return player:hasSkill(self) and (data.card.color == Card.NoColor or data.card.suit == Card.NoSuit)
    and player:usedSkillTimes(self.name, Player.HistoryRound) == 0
  end,
  on_use = function(self, event, target, player, data)
    local room = player.room
    player:drawCards(1, self.name)
  end,

  refresh_events = {fk.CardUseFinished, fk.AfterTurnEnd},
  can_refresh = function(self, event, target, player, data)
    if event == fk.CardUseFinished then
      return player:hasSkill(self) and target == player and U.IsUsingHandcard(player, data) and player:usedSkillTimes(self.name, Player.HistoryRound) > 0
    else
      return player:hasSkill(self) and player:getMark("weijidao_reset-turn") > 0
    end
  end,
  on_refresh = function(self, event, target, player, data)
    if event == fk.CardUseFinished then
      player.room:addPlayerMark(player, "weijidao_reset-turn")
    else
      player:setSkillUseHistory(self.name, 0, Player.HistoryRound) 
    end
  end,
}

lzsj__xuanzhushi:addRelatedSkill(xuanzhushi_trigger)
zhangzuolin:addSkill(lzsj__xuanzhushi)
zhangzuolin:addSkill(lzsj__yunfenglei)
zhangzuolin:addSkill(lzsj__weijidao)

Fk:loadTranslationTable{
  ["fengtian"] = "奉天",
  ["lzsj__zhangzuolin"] = "张作霖",
  ["designer:lzsj__zhangzuolin"] = "Erosa",
  ["cv:lzsj__zhangzuolin"] = "浩潇-淼龙",
  ["lzsj__xuanzhushi"] = "旋诸势",
  [":lzsj__xuanzhushi"] = "阶段技，出牌阶段，你可令一名其他角色将每个区域各一张牌当一张非【毒】基本牌对你使用（其选择）；然后你可展示其一张手牌，若与转化底牌花色均不同，之无效。",
  ["#lzsj__xuanzhushi"] = "你可以选择一名其他角色，其将每个区域各一张牌当一张基本牌对你使用",
  ["#lzsj__xuanzhushi-choose"] = "请选择每个区域各一张牌",
  ["#lzsj__xuanzhushi-show"] = "你可以展示%src一张手牌",
  ["lzsj__yunfenglei"] = "蕴风雷",
  [":lzsj__yunfenglei"] = "回合技，当一名角色于你回合内失去最后的手牌后，其可视为使用【顺手牵羊】。",
  ["#lzsj__yunfenglei-use"] = "你可视为使用【顺手牵羊】",
  ["lzsj__weijidao"] = "为己道",
  [":lzsj__weijidao"] = "轮次技，一名角色使用无花色牌后，你可摸一张牌，你使用过手牌的回合结束后，重置此技能。",

  ["$lzsj__xuanzhushi1"] = "进了山海关，都得给我交买路钱！",
  ["$lzsj__xuanzhushi2"] = "那江湖不是打打杀杀，那江湖是人情世故~",
  ["$lzsj__yunfenglei1"] = "奉天兵工厂冒烟，小日本以为咱是造锄头？",
  ["$lzsj__yunfenglei2"] = "小六子勾搭南边？老子能捧他也能废他！",
  ["$lzsj__weijidao1"] = "当胡子靠狠，当大帅？靠妈了个巴子的算盘！",
  ["$lzsj__weijidao2"] = "修铁路收税？这叫江湖规矩！",
  ["~lzsj__zhangzuolin"] = "算计老子一辈子…最后竟用两吨炸药结账？",
}

local zhangxueliang = General(extension, "lzsj__zhangxueliang", "fengtian", 4)

local lzsj__dibukejiao = fk.CreateTriggerSkill{
  name = "lzsj__dibukejiao",
  events = {fk.CardUseFinished},
  anim_type = "offensive",
  dynamic_desc = function(self, player)
    local texts = "lzsj__dibukejiao"
    if player:getMark("@@lzsj__dibukejiao") > 0 then
      texts = "lzsj__dibukejiao_edit"
    end
    return texts
  end,
  can_trigger = function(self, event, target, player, data)
    if player:hasSkill(self) and data.card.color == Card.Red then
      if player:getMark("@@lzsj__dibukejiao") > 0 then
        return table.contains(U.getActualUseTargets(player.room, data, event), player.id)
      else
        local to = player.room:getPlayerById(U.getActualUseTargets(player.room, data, event)[1])
        if to then
          return player:distanceTo(to) <= 1 and U.isOnlyTarget(to, data, event)
        end
      end
    end
  end,
  on_cost = function(self, event, target, player, data)
    local room = player.room
    local names = table.filter(U.getAllCardNames('bt'), function (len) return string.find(len, "support") or string.find(len, "slash") end)
    local cards = U.prepareDeriveCards(room, table.map(names, function (name) return {name, Card.NoSuit, 0} end), self.name)
    local use = U.askForUseRealCard(room, player, cards, nil, self.name, "#lzsj__dibukejiao-use",
      {expand_pile = cards, bypass_times = true}, true, true)
    if use then
      self.cost_data = use
      return true
    end
  end,
  on_use = function(self, event, target, player, data)
    local use = {
      card = Fk:cloneCard(self.cost_data.card.name),
      from = self.cost_data.from,
      tos = self.cost_data.tos,
      extraUse = true,
    }
    use.card.skillName = self.name
    player.room:useCard(use)
    if player:getMark("@@lzsj__dibukejiao") == 0 and not use.damageDealt then
      player:drawCards(2, self.name)
      DIY.removePlayer(player, "-turn")
      player.room:addTableMark(player, MarkEnum.InvalidSkills .. "-round", self.name)
    end
  end,
}

local checkUniqueRoles = function(room)
  local identity_count = { lord = 0, loyalist = 0, rebel = 0, renegade = 0 }--身份出现次数
  for _, p in ipairs(room.alive_players) do
      local role = p.role
      if identity_count[role] then
          identity_count[role] = identity_count[role] + 1
      else
          -- 处理未知身份（如扩展包角色）
          return false
      end
  end
  -- 校验主公唯一性
  if identity_count.lord ~= 1 then return false end
  -- 校验其他身份不重复
  for role, count in pairs(identity_count) do
      if role ~= "lord" and count > 1 then
          return false
      end
  end
  return true
end

local lzsj__zhongbukeyan = fk.CreateTriggerSkill{
  name = "lzsj__zhongbukeyan",
  --frequency = Skill.Limited,
  events = {fk.RoundEnd},
  can_trigger = function(self, event, target, player, data)
    --[[if  and player:usedSkillTimes(self.name, Player.HistoryGame) == 0 then
      if event == fk.RoundStart or target == player then
        
      end
    end]]
    return player:hasSkill(self)
  end,
  on_cost = function(self, event, target, player, data)
    local room = player.room
    local targets = table.filter(room:getOtherPlayers(player), function (p)
      return not table.contains(player:getTableMark("zhongbukeyan_record"), p.id) end)
    local tos = room:askForChoosePlayers(player, table.map(targets, Util.IdMapper), 1, 1, "#lzsj__zhongbukeyan-choose", self.name, true)
    if #tos > 0 then
      self.cost_data = tos[1]
      return true
    end
  end,
  on_use = function(self, event, target, player, data)
    local room = player.room
    local to = room:getPlayerById(self.cost_data)
    room:addTableMarkIfNeed(player, "zhongbukeyan_record", to.id)
    room:addPlayerMark(to, "@@lzsj__zhongbukeyan")
    to:gainAnExtraTurn(false, self.name)
  end,

  refresh_events = {fk.TurnEnd},
  can_refresh = function(self, event, target, player, data)
    return player:hasSkill(self) and (target:getMark("@@lzsj__zhongbukeyan") > 0 or (target == player and player:getMark("@@zhongbukeyan_over") > 0))
  end,
  on_refresh = function(self, event, target, player, data)
    local room = player.room
    if target:getMark("@@lzsj__zhongbukeyan") > 0 then
      room:setPlayerMark(target, "@@lzsj__zhongbukeyan", 0)
      target:turnOver()
      local n = 0
      room.logic:getEventsOfScope(GameEvent.ChangeHp, 1, function (e)
        local damage = e.data[5]
        if damage and damage.damage > 0 then
          n = n + damage.damage
        end
      end, Player.HistoryTurn)
      room:handleAddLoseSkills(player, "lzsj__xiangle")
      if n >= 1 then
        room:addPlayerMark(player, "@@lzsj__dibukejiao")
      end
      if n >= 2 then
        room:changeKingdom(player, "west", true)
        room:addPlayerMark(player, "@@zhongbukeyan_over")
        player:gainAnExtraTurn(true, self.name)
      end
    elseif player:getMark("@@zhongbukeyan_over") > 0 then
      room:setPlayerMark(player, "@@zhongbukeyan_over", 0)
      player:turnOver()
    end
  end,
}

local xiangle = fk.CreateTriggerSkill{
  name = "lzsj__xiangle",
  events = {fk.TargetConfirmed},
  anim_type = "defensive",
  frequency = Skill.Compulsory,
  can_trigger = function(self, event, target, player, data)
    return target == player and player:hasSkill(self) and data.card.trueName == "slash"
  end,
  on_use = function(self, event, target, player, data)
    local room = player.room
    if #room:askForDiscard(room:getPlayerById(data.from), 1, 1, false, self.name, true, ".|.|.|.|.|basic", "#xiangle-discard:"..player.id) == 0 then
      table.insertIfNeed(data.nullifiedTargets, player.id)
    end
  end,
}

Fk:addSkill(xiangle)

zhangxueliang:addSkill(lzsj__dibukejiao)
zhangxueliang:addSkill(lzsj__zhongbukeyan)
zhangxueliang:addRelatedSkill(xiangle)

Fk:loadTranslationTable{
  ["lzsj__zhangxueliang"] = "张学良",
  ["designer:lzsj__zhangxueliang"] = "浩潇-淼龙",
  ["cv:lzsj__zhangxueliang"] = "英雄小串",
  ["lzsj__dibukejiao"] = "敌不可剿",
  [":lzsj__dibukejiao"] = "（仅）以你（距离1以内的角色）为目标的红色牌结算后，你可视为使用一张任意【杀】或【援护】（，若未因此造成伤害，你摸两张牌，于本回合调离且此技能于本轮失效）。",
  ["@@lzsj__dibukejiao"] = "敌不可剿<font color=red><b>改</b></font>",
  [":lzsj__dibukejiao_edit"] = "以你为目标的红色即时牌结算后，你可视为使用一张任意【杀】或【援护】。",
  ["#lzsj__dibukejiao-use"] = "敌不可剿：请选择视为使用的牌",
  ["lzsj__zhongbukeyan"] = "忠不可言",
  [":lzsj__zhongbukeyan"] = "一轮结束时，你可令一名未以此法选择过的其他角色进行一个结束后翻面的额外回合；此回合结束时，若至少造成0/1/2点伤害，你获得“享乐”/删去“敌不可剿”括号内容/执行一个额外回合并翻面。",
  ["#lzsj__zhongbukeyan-choose"] = "忠不可言：你可令一名其他角色进行一个结束后翻面的额外回合",
  ["@@lzsj__zhongbukeyan"] = "额外回合",
  ["@@zhongbukeyan_over"] = "<font color=red><b>忠！诚！</b></font>",
  ["lzsj__xiangle"] = "享乐",
  [":lzsj__xiangle"] = "锁定技，当你成为【杀】的目标后，你令使用者选择：1. 弃置一张基本牌；2. 此【杀】对你无效。",

  ["$lzsj__dibukejiao1"] = "松花江冰封战刃，北大营空留旗号！",
  ["$lzsj__dibukejiao2"] = "沈阳枪未响，已失山河三千里！",
  ["$lzsj__zhongbukeyan1"] = "华清池水彻骨寒，兵谏书成烫手铁！",
  ["$lzsj__zhongbukeyan2"] = "五间厅枪声落，从此忠奸皆哑谜！",
  ["$lzsj__xiangle"] = "西安雪融作台北雨，打湿少帅绶带星。",
  ["~lzsj__zhangxueliang"] = "消失的旧时光，回头看的片段，有一些风霜。",
}

local lixianglan = General(extension, "lzsj__lixianglan", "qun", 3, 3, General.Female)
lixianglan.strategy = "scheme"

local lzsj__yelaixiang = fk.CreateTriggerSkill{
  name = "lzsj__yelaixiang",
  events = {fk.EventPhaseStart},
  anim_type = "drawCards",
  can_trigger = function(self, event, target, player, data)
    if player:hasSkill(self) then
      if target.phase == Player.Judge then
        local ids = table.filter(player.room.discard_pile, function (id) return Fk:getCardById(id).suit == Card.Heart end)
        return #ids > 0 and player:usedSkillTimes(self.name, Player.HistoryRound) <= player:getMark("lzsj__yelaixiang-round")
      elseif target.phase == Player.Discard then
        return target:getMark("yelaixiang-turn") > 0 and not target:isKongcheng()
       end
    end
  end,
  on_cost = function(self, event, target, player, data)
    if target.phase == Player.Judge then
      return player.room:askForSkillInvoke(player, self.name, nil, "#lzsj__yelaixiang:"..target.id)
    else
      return player.room:askForSkillInvoke(target, self.name, nil, "#yelaixiang-show")
    end
  end,
  on_use = function(self, event, target, player, data)
    local room = player.room
    if target.phase == Player.Judge then
      room:addPlayerMark(target, "yelaixiang-turn")
      local ids = table.filter(player.room.discard_pile, function (id) return Fk:getCardById(id).suit == Card.Heart end)
      if #ids > 0 then
        local id = room:askForCardChosen(player, player, { card_data = {{self.name, ids}} }, self.name)
        room:useVirtualCard("lvshi__indulgence", {id}, player, target, self.name, true)
      end
    else
      target:showCards(target:getCardIds("h"))
      if not table.find(target:getCardIds("h"), function (id) return Fk:getCardById(id).trueName == "slash" end) then
        room:endTurn()
        room:delay(200)
        target:gainAnExtraTurn(true, self.name)
        room:setPlayerMark(player, "lzsj__yelaixiang-round", 1)
      end
    end
  end,
}

local lzsj__changxiuwu = fk.CreateTriggerSkill{
  name = "lzsj__changxiuwu",
  anim_type = "switch",
  switch_skill_name = "lzsj__changxiuwu",
  events = {fk.StartJudge, fk.TurnEnd},
  can_trigger = function(self, event, target, player, data)
    if player:hasSkill(self) then
      return event == fk.StartJudge or target == player
    end
  end,
  on_cost = function(self, event, target, player, data)
    local room = player.room
    local cards
    if player:getSwitchSkillState(self.name, false) == fk.SwitchYang then
      cards = room:askForCard(player, 2, 2, true, self.name, true, ".", "#lzsj__changxiuwu1")
    else
      cards = room:askForCard(player, 1, 1, true, self.name, true, ".|.|.|.|.|basic|.", "#lzsj__changxiuwu2")
    end
    if #cards > 0 then
      self.cost_data = cards
      return true
    end
  end,
  on_use = function(self, event, target, player, data)
    local room = player.room
    local cards = self.cost_data
    if player:getSwitchSkillState(self.name, true) == fk.SwitchYang then
      room:moveCardTo(cards, Card.DrawPile, nil, fk.ReasonPut, self.name, nil)
      room:askForGuanxing(player, room:getNCards(2), {2, 2}, {0, 0})
      local ids = table.filter(room.discard_pile, function (id) return Fk:getCardById(id).type ~= Card.TypeBasic end)
      if #ids > 0 then
        local id = room:askForCardChosen(player, player, { card_data = {{self.name, ids}} }, self.name)
        room:moveCardTo(id, Card.PlayerHand,player, fk.ReasonJustMove, self.name, nil, true, player.id)
      end
    else
      room:moveCards({
        ids = cards,
        from = player.id,
        toArea = Card.DrawPile,
        moveReason = fk.ReasonPut,
        skillName = self.name,
        drawPilePosition = -1,
      })
      player:drawCards(2, self.name)
    end
  end,
}
lixianglan:addSkill(lzsj__yelaixiang)
lixianglan:addSkill(lzsj__changxiuwu)
Fk:loadTranslationTable{
  ["lzsj__lixianglan"] = "李香兰",
  ["designer:lzsj__lixianglan"] = "Erosa",
  ["lzsj__yelaixiang"] = "夜来香",
  [":lzsj__yelaixiang"] = "轮次技，一名角色的判定阶段开始时，你可将弃牌堆内的一张红桃牌当【乐不思蜀】对其使用。若如此做，其弃牌阶段开始时可展示所有手牌，若没有【杀】，其结束此回合并进行一个额外的回合，且此技能于此轮改为限两次。",
  ["#lzsj__yelaixiang"] = "你可对%src使用【乐不思蜀】",
  ["#yelaixiang-show"] = "你可以展示所有手牌，若没有【杀】，结束此回合并进行一个额外的回合",
  ["lzsj__changxiuwu"] = "长袖舞",
  [":lzsj__changxiuwu"] = "回合技，转换技，一名角色判定前，或你的回合结束时，你可①将两张牌置于牌堆顶，从弃牌堆获得一张非基本牌，②将一张基本牌置于牌堆底，摸两张牌。",
  ["#lzsj__changxiuwu1"] = "你可以将两张牌置于牌堆顶",
  ["#lzsj__changxiuwu2"] = "你可以将一张基本牌置于牌堆底",
}

local kimiisung = General(extension, "lzsj__kimIIsung", "njin", 4)
kimiisung.strategy = "schemecourage"

local jihongwan_trigger = fk.CreateTriggerSkill{
  name = "#jihongwan_trigger",
  mute = true,
  events = {fk.TargetSpecifying},
  can_trigger = function(self, event, target, player, data)
    if target == player and player:hasSkill(self) and data.card.trueName == "slash" and data.card.skillName == "lzsj__jihongwan" then
      local targets = player.room:getUseExtraTargets(data, false, true)
      targets = table.filter(targets, function(p) return player.room:getPlayerById(p):getMark("@@lzsj__jihongwan") > 0 end)
      return #targets > 0
    end
  end,
  on_cost = Util.TrueFunc,
  on_use = function(self, event, target, player, data)
    local room = player.room
    local targets = room:getUseExtraTargets(data, false, true)
    targets = table.filter(targets, function(p) return player.room:getPlayerById(p):getMark("@@lzsj__jihongwan") > 0 end)
    for _, pid in ipairs(targets) do
      AimGroup:addTargets(room, data, pid)
    end
    room:sendLog{
      type = "#AddTargetsBySkill",
      from = player.id,
      to = self.cost_data,
      arg = self.name,
      arg2 = data.card:toLogString()
    }
  end,
}

local lzsj__jihongwan = fk.CreateActiveSkill{
  name = "lzsj__jihongwan",
  anim_type = "offensive",
  prompt = "你可选择一名计算与你距离最远的角色，视为对其使用火杀",
  card_num = 0,
  target_num = 1,
  can_use = function(self, player)
    return player:usedSkillTimes(self.name, Player.HistoryPhase) == 0
  end,
  card_filter = Util.FalseFunc,
  target_filter = function(self, to_select, selected, _, _, _, player)
    local to = Fk:currentRoom():getPlayerById(to_select)
    if table.every(Fk:currentRoom().alive_players, function (p) return p:distanceTo(player) <= to:distanceTo(player) end) 
    or to:getMark("lzsj__jihongwan") > 0 then
      return #selected == 0 and player:canUseTo(Fk:cloneCard("fire__slash"), to, {bypass_distances = true, bypass_times = true})
    end
  end,
  on_use = function(self, room, effect)
    local player = room:getPlayerById(effect.from)
    local to = room:getPlayerById(effect.tos[1])
    room:useVirtualCard("fire__slash", nil, player, to, self.name, true)
    if player:distanceTo(to) > to:distanceTo(player) then
      room:addPlayerMark(to, "lzsj__jihongwan")
    else
      if table.every(room:getOtherPlayers(player), function (p) return player:distanceTo(p) >= player:distanceTo(to) end) then
        room:addPlayerMark(to, "@@lzsj__jihongwan")
      end
    end
  end,
}

local weichiri_trigger = fk.CreateTriggerSkill{
  name = "#weichiri_trigger",
  mute = true,
  events = {fk.RoundStart},
  can_trigger = function(self, event, target, player, data)
    if player:hasSkill(self) then
      return table.every(player.room:getOtherPlayers(player), function (p) return not p:inMyAttackRange(player) end)
    end
  end,
  on_cost = Util.TrueFunc,
  on_use = function(self, event, target, player, data)
    local room = player.room
    --被尽可能移动气晕
    local weapons, armors, offensivehorses, defensivehorses, treasures = {}, {}, {}, {}, {}
    for _, p in ipairs(room:getOtherPlayers(player)) do
      for _, id in ipairs(p:getCardIds("e")) do
        local card = Fk:getCardById(id)
        if player:canMoveCardIntoEquip(id, false) and card.color == Card.Red then
          if card.sub_type == Card.SubtypeWeapon then
            table.insertIfNeed(weapons, id)
          elseif card.sub_type == Card.SubtypeArmor then
            table.insertIfNeed(armors, id)
          elseif card.sub_type == Card.SubtypeOffensiveRide then
            table.insert(offensivehorses, id)
          elseif card.sub_type == Card.SubtypeDefensiveRide then
            table.insert(defensivehorses, id)
          elseif card.sub_type == Card.SubtypeTreasure then
            table.insert(treasures, id)
          end
        end
      end
    end
    local card_data = {}
    local data = {
      to = target.id,
      min = 1,
      max = 5,
      skillName = skill_name,
      prompt = "请选择每种子类别的装备牌",
    }
    if #weapons > 0 then
      table.insert(card_data, {"type_weapon", weapons})
    end
    if #armors > 0 then
      table.insert(card_data, {"type_armor", armors})
    end
    if #offensivehorses > 0 then
      table.insert(card_data, {"type_offensive_horse", offensivehorses})
    end
    if #defensivehorses > 0 then
      table.insert(card_data, {"type_defensive_horse", defensivehorses})
    end
    if #treasures > 0 then
      table.insert(card_data, {"type_treasure", treasures})
    end
    if #card_data == 0 then return {} end
    local ret = room:askForPoxi(player, "askforCardsChosenFromAreas", card_data, data, cancelable)
    if #ret > 0 then
      room:recover{who = player, num = #ret, skillName = self.name}
      for _, id in ipairs(ret) do
        U.moveCardIntoEquip(room, player, id, self.name, true, player)
      end
    end
    --room:handleAddLoseSkills(player, "-lzsj__weichiri")
    room:addPlayerMark(player, "isSun")
    room:setPlayerMark(player, "@lzsj__weichiri", 0)
  end,

  refresh_events = {fk.Damage, fk.DamageCaused},
  can_refresh = function(self, event, target, player, data)
    if event == fk.Damage then
      return target == player and player:hasSkill(self) and player:getMark("isSun") == 0
    else
      return player:hasSkill(self, true, true) and player:getMark("isSun") > 0 and data.damageType == fk.FireDamage
      and data.to ~= player
    end
  end,
  on_refresh = function(self, event, target, player, data)
    if event == fk.Damage then
      player.room:addPlayerMark(player, "@lzsj__weichiri")
    else
      data.damage = data.damage + 1
    end
  end,
}

local lzsj__weichiri = fk.CreateDistanceSkill{
  name = "lzsj__weichiri",
  correct_func = function(self, from, to)
    if from:hasSkill(self) and from.hp > 2 and from:getMark("isSun") == 0 then
      return -1 - from:getMark("@lzsj__weichiri")
    end
    if to:hasSkill(self) and to.hp <= 2 and to:getMark("isSun") == 0 then
      return 1 + to:getMark("@lzsj__weichiri")
    end
  end,
}

lzsj__jihongwan:addRelatedSkill(jihongwan_trigger)
lzsj__weichiri:addRelatedSkill(weichiri_trigger)
kimiisung:addSkill(lzsj__jihongwan)
kimiisung:addSkill(lzsj__weichiri)

Fk:loadTranslationTable{
  ["lzsj__kimIIsung"] = "金日成",
  ["#lzsj__kimIIsung"] = "The Son of the Sun",
  ["designer:lzsj__kimIIsung"] = "浩潇-淼龙",
  ["lzsj__jihongwan"] = "击红丸",
  ["#jihongwan_trigger"] = "击红丸",
  ["@@lzsj__jihongwan"] = "<font color=\"#E8251E\"><b>额外目标</b></font>",
  [":lzsj__jihongwan"] = "阶段技，你可视为对计算与你距离最远的角色使用一张火【杀】（无次数限制），若此时你计算与其距离较其计算你距离更近/为最近，其永久成为此技能的合法/额外目标。",
  ["lzsj__weichiri"] = "为炽日",
  ["@lzsj__weichiri"] = "<font color=\"#E8251E\"><b>为炽日</b></font>",
  [":lzsj__weichiri"] = "锁定技，你视为拥有“义从”，当你造成伤害后，“义从”描述中距离数字+1；一轮开始时，若你不在所有其他角色的攻击范围内，你尽可能地将场上的红色装备牌移动至你并回复等量体力，然后你失去“义从”，令此局游戏其他角色受到的火焰伤害+1。",

  ["$lzsj__jihongwan1"] = "白头山星火，终成燎原势！（백두산 성화, 마침내 불길이 되어!）",
  ["$lzsj__jihongwan2"] = "游击队的脚印，是共和国最初的疆界！（유격대의 발자국이 공화국의 첫 경계다!）",
  ["$lzsj__weichiri1"] = "人民仰望的太阳，永不西沉！（인민이 우러러보는 태양은 영원히 지지 않는다!）",
  ["$lzsj__weichiri2"] = "主体的光芒，照亮千里马的前路！（주체의 빛이 천리마의 길을 밝힌다!）",
  ["~lzsj__kimIIsung"] = "山河仍在……但烽火台的狼烟已熄。（산하는 남았으나 봉화대의 연기는 꺼졌다...）",
}

local xiaowang = General(extension, "lzsj__xiaowang", "gong", 4)
xiaowang.strategy = "scheme"

local lzsj__baihuokeju = fk.CreateTriggerSkill{
  name = "lzsj__baihuokeju",
  frequency = Skill.Compulsory,
  events = {fk.EventPhaseStart},
  can_trigger = function(self, event, target, player, data)
    if target == player and player:hasSkill(self) and player.phase == Player.Discard then
      local names = {"peach", "analeptic", "pear", "god_salvation"}
      local ids = table.filter(player.room.discard_pile, function (id) return table.contains(names, Fk:getCardById(id).trueName) end)
      return #ids > 0
    end
  end,
  on_use = function(self, event, target, player, data)
    local room = player.room
    local names = {"peach", "analeptic", "pear", "god_salvation"}
    local ids = table.filter(room.discard_pile, function (id) return table.contains(names, Fk:getCardById(id).trueName) end)
    if #ids > 0 then
      local id = room:askForCardChosen(player, player, { card_data = {{self.name, ids}} }, self.name)
      room:moveCardTo(id, Card.PlayerHand, player, fk.ReasonJustMove, self.name, nil, true, player.id)
    end
    local cards = table.filter(player:getCardIds("h"), function (id)
      return table.contains(names, Fk:getCardById(id).trueName) and table.contains(ls.gethidecards(player), id)
    end)
    if #cards > 0 then
      DIY.ShowCards(player, cards)
    end
  end,
}

local lzsj__yijiaonanqiu = fk.CreateTriggerSkill{
  name = "lzsj__yijiaonanqiu",
  frequency = Skill.Compulsory,
  events = {fk.TurnStart, fk.EventPhaseStart, fk.EventPhaseEnd},
  can_trigger = function(self, event, target, player, data)
    if target == player and player:hasSkill(self) then
      if event == fk.EventPhaseStart or event == fk.EventPhaseEnd then
        return player.phase == Player.Play and player:getMark("yijiaonanqiu-turn") > 0
      else
        return true
      end
    end
  end,
  on_use = function(self, event, target, player, data)
    local room = player.room
    if event == fk.TurnStart then
      room:setPlayerMark(player, "@lzsj__yijiaonanqiu", player:getMark("yijiaonanqiu"))
      room:addPlayerMark(player, "yijiaonanqiu-turn")
    else
      if event == fk.EventPhaseStart then
        player:drawCards(1, self.name)
      elseif event == fk.EventPhaseEnd then
        if #room.logic:getEventsOfScope(GameEvent.UseCard, 1, function(e)
        local use = e.data[1]
        return use.from == player.id end, Player.HistoryPhase) == 0 then
          room:loseHp(player, 1, self.name)
        end
        if player:isAlive() and player:getMark("@lzsj__yijiaonanqiu") > 0 then
          room:removePlayerMark(player, "@lzsj__yijiaonanqiu")
          player:gainAnExtraPhase(Player.Play, true)
        end
      end
    end
  end,

  refresh_events = {fk.HpRecover},
  can_refresh = function(self, event, target, player, data)
    return player:hasSkill(self) and target == player
  end,
  on_refresh = function(self, event, target, player, data)
    player.room:addPlayerMark(player, "yijiaonanqiu")
  end,
}

xiaowang:addSkill(lzsj__baihuokeju)
xiaowang:addSkill(lzsj__yijiaonanqiu)

Fk:loadTranslationTable{
  ["lzsj__xiaowang"] = "神秘角色",
  ["designer:lzsj__xiaowang"] = "浩潇-淼龙",
  ["lzsj__baihuokeju"] = "百货可居",
  [":lzsj__baihuokeju"] = "锁定技，弃牌阶段开始时，你从弃牌堆中获得一张可回复体力的牌。然后你明置手牌中所有可回复体力的牌。",
  ["lzsj__yijiaonanqiu"] = "一觉难求",
  [":lzsj__yijiaonanqiu"] = "锁定技，回合开始时，你须于此回合额外进行X个出牌阶段，出牌阶段开始时，你摸一张牌，出牌阶段结束时，若你未于此阶段使用过牌，你失去1点体力。（X为你本局游戏回复体力的次数）",
  ["@lzsj__yijiaonanqiu"] = "一觉难求",

  ["$lzsj__baihuokeju1"] = "酒心巧克力里的炮弹，可比子弹贵多了！",
  ["$lzsj__baihuokeju2"] = "我兜里的打火机，才是点烟成金的钥匙。",
  ["$lzsj__baihuokeju3"] = "粮票在供销社，煤票在运输队，想活命？得先过我这条批文！",
  ["$lzsj__yijiaonanqiu1"] = "当年抢位子熬瞎了眼，如今坐稳了……反倒不敢合眼了！",
  ["$lzsj__yijiaonanqiu2"] = "打火机烧光了太阳能，我的油水，倒越烧越旺了！",
  ["$lzsj__yijiaonanqiu3"] = "梦里全是账本着火，醒来还得给纪委递锦旗！",
  ["~lzsj__xiaowang"] = "百货可居？居到最后…连我的名字都成了禁词…",
}

return extension